import axios from 'axios'
import { ElMessage } from 'element-plus'
import router from '@/router'
import { useUserStore } from '@/stores/user'

const service = axios.create({
  baseURL: 'http://localhost:8080/api',
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 是否正在刷新token
let isRefreshing = false
// 重试队列
let retryRequests = []

// 请求拦截器
service.interceptors.request.use(
  async config => {
    const userStore = useUserStore()
    
    // 检查是否需要跳过认证
    if (config.headers['X-Skip-Auth']) {
      delete config.headers['X-Skip-Auth']
      return config
    }

    // 检查token有效性
    if (userStore.token) {
      // 如果token即将过期（比如还有5分钟），尝试刷新
      if (userStore.tokenExpireTime - Date.now() < 5 * 60 * 1000) {
        if (!isRefreshing) {
          isRefreshing = true
          try {
            const refreshed = await userStore.refreshToken()
            if (!refreshed) {
              // 刷新失败，清除用户状态
              userStore.logout()
              router.push('/login')
              return Promise.reject(new Error('登录已过期，请重新登录'))
            }
          } finally {
            isRefreshing = false
          }
        } else {
          // 如果正在刷新token，将请求加入重试队列
          return new Promise(resolve => {
            retryRequests.push(() => {
              resolve(service(config))
            })
          })
        }
      }
      
      // 添加token到请求头
      config.headers['Authorization'] = `Bearer ${userStore.token}`
    }
    
    // 添加请求时间戳
    config.headers['X-Request-Time'] = Date.now()
    
    return config
  },
  error => {
    console.error('请求错误:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
service.interceptors.response.use(
  response => {
    const res = response.data
    
    // 如果响应成功但业务状态码不是200
    if (res.code !== 200) {
      ElMessage({
        message: res.message || '请求失败',
        type: 'error',
        duration: 5 * 1000
      })

      // 处理特定错误码
      if (res.code === 401) {
        handleUnauthorized()
      } else if (res.code === 403) {
        ElMessage.error('权限不足')
        router.push('/')
      } else if (res.code === 500) {
        ElMessage.error('服务器内部错误')
      }
      
      return Promise.reject(new Error(res.message || '请求失败'))
    }
    
    return res
  },
  async error => {
    console.error('响应错误:', error)
    
    if (error.response) {
      const { status, data } = error.response
      
      // 处理401错误
      if (status === 401) {
        return handleUnauthorized()
      }
      
      // 处理其他错误
      let message = '网络错误'
      switch (status) {
        case 400:
          message = data?.message || '请求参数错误'
          break
        case 403:
          message = '拒绝访问'
          break
        case 404:
          message = '请求地址不存在'
          break
        case 500:
          message = '服务器内部错误'
          break
        case 502:
          message = '网关错误'
          break
        case 503:
          message = '服务不可用'
          break
        case 504:
          message = '网关超时'
          break
        default:
          message = data?.message || `连接错误${status}`
      }
      
      ElMessage({
        message,
        type: 'error',
        duration: 5 * 1000
      })
    } else if (error.request) {
      ElMessage.error('网络连接失败，请检查网络')
    } else {
      ElMessage.error(error.message || '请求配置错误')
    }
    
    return Promise.reject(error)
  }
)

// 处理未授权错误
const handleUnauthorized = async () => {
  const userStore = useUserStore()
  
  // 清除用户状态
  userStore.logout()
  
  // 显示提示
  ElMessage.error('登录已过期，请重新登录')
  
  // 保存当前路由
  const currentPath = router.currentRoute.value.fullPath
  if (currentPath !== '/login') {
    router.push({
      path: '/login',
      query: { redirect: currentPath }
    })
  }
  
  return Promise.reject(new Error('未授权，请重新登录'))
}

export default service 